package gwtappcontainer.server.apps.security;
import static gwtappcontainer.server.apps.security.OfyService.ofy;
import static org.junit.Assert.assertTrue;
import gwtappcontainer.server.apps.security.PrivilegeEntity;
import gwtappcontainer.server.apps.security.Privileges;
import gwtappcontainer.server.apps.security.RoleEntity;
import gwtappcontainer.server.apps.security.SecurityAPI;
import gwtappcontainer.server.apps.security.UserEntity;
import gwtappcontainer.shared.apis.APIResponse;
import gwtappcontainer.shared.apis.APIResponse.Status;
import gwtappcontainer.shared.apps.security.RoleProp;
import gwtappcontainer.shared.apps.security.UserProp;
import gwtappcontainer.testhelpers.APITestHelper3;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.googlecode.objectify.Key;
public class SecurityAPITest {
private final APITestHelper3 helper = new APITestHelper3();
@Before
public void setUp() {
helper.setUp();
}
@After
public void tearDown() {
purgeAllSecurityEntities();
helper.tearDown();
}
@SuppressWarnings("unchecked")
@Test
public void addPrivilegeTest() {
SecurityAPI api = new SecurityAPI();
//should have the right privilege
APIResponse response = api.addPrivilege("test", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.addPrivilege("test", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.addPrivilege("test", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.addPrivilege("test",
helper.loginWithPrivilege(Privileges.EDIT_PRIVILEGE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllPrivileges();
TreeSet<String> all = (TreeSet<String>) response.object;
assertTrue(all.contains("TEST"));
//adding the same privilege again should give correct error
response = api.addPrivilege("test",
helper.loginWithPrivilege(Privileges.EDIT_PRIVILEGE));
assertTrue(response.statusCode == Status.ERROR_RESOURCE_ALREADY_EXISTS);
//admin can add as well
response = api.addPrivilege("test2", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllPrivileges();
all = (TreeSet<String>) response.object;
assertTrue(all.contains("TEST2"));
}
@SuppressWarnings("unchecked")
@Test
public void deletePrivilegeTest() {
SecurityAPI api = new SecurityAPI();
APIResponse response = api.addPrivilege("test",
helper.loginWithPrivilege(Privileges.EDIT_PRIVILEGE));
//should have the right privilege
response = api.deletePrivilege("test", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.deletePrivilege("test", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.deletePrivilege("test", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.deletePrivilege("test",
helper.loginWithPrivilege(Privileges.EDIT_PRIVILEGE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllPrivileges();
TreeSet<String> all = (TreeSet<String>) response.object;
assertTrue(! all.contains("TEST"));
//deleting the same privilege again should give correct error
response = api.deletePrivilege("test",
helper.loginWithPrivilege(Privileges.EDIT_PRIVILEGE));
assertTrue(response.statusCode == Status.ERROR_RESOURCE_DOES_NOT_EXIST);
//admin can delete as well
response = api.addPrivilege("test",
helper.loginWithPrivilege(Privileges.EDIT_PRIVILEGE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.deletePrivilege("test", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
all = (TreeSet<String>) api.getAllPrivileges().object;
assertTrue(! all.contains("TEST"));
}
@SuppressWarnings("unchecked")
@Test
public void getAllPrivilegesTest() {
SecurityAPI api = new SecurityAPI();
TreeSet<String> allPrivileges = (TreeSet<String>) api.getAllPrivileges().object;
assertTrue(allPrivileges.size() == 0);
@SuppressWarnings("unused")
APIResponse response = api.addPrivilege("abc", helper.loginAsSuperUser());
response = api.addPrivilege("xyz", helper.loginAsSuperUser());
response = api.addPrivilege("ishaprivilege", helper.loginAsSuperUser());
allPrivileges = (TreeSet<String>) api.getAllPrivileges().object;
//ensure sorting
assertTrue(allPrivileges.size() == 3); //EDIT_PRIVILEGE will also be added
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.addAll(allPrivileges);
assertTrue(arrayList.get(0).equals("ABC"));
assertTrue(arrayList.get(1).equals("ISHAPRIVILEGE"));
assertTrue(arrayList.get(2).equals("XYZ"));
}
@SuppressWarnings("unchecked")
@Test
public void addRoleTest() {
SecurityAPI api = new SecurityAPI();
//should have the right privilege
APIResponse response = api.addRole("test", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.addRole("test", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.addRole("test", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.addRole("test",
helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllRoles();
TreeSet<RoleProp> all = (TreeSet<RoleProp>) response.object;
assertTrue(all.first().role.equals("TEST"));
//adding the same role again should give correct error
response = api.addRole("test",
helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.ERROR_RESOURCE_ALREADY_EXISTS);
//admin can add as well
response = api.addRole("test2", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllRoles();
all = (TreeSet<RoleProp>) response.object;
assertTrue(all.last().role.equals("TEST2"));
}
@SuppressWarnings("unchecked")
@Test
public void deleteRoleTest() {
SecurityAPI api = new SecurityAPI();
APIResponse response = api.addRole("test",
helper.loginWithPrivilege(Privileges.EDIT_ROLE));
//should have the right privilege
response = api.deleteRole("test", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.deleteRole("test", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.deleteRole("test", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.deleteRole("test",
helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllRoles();
TreeSet<RoleProp> all = (TreeSet<RoleProp>) response.object;
assertTrue(all.size() == 0);
//deleting the same role again should give correct error
response = api.deleteRole("test",
helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.ERROR_RESOURCE_DOES_NOT_EXIST);
//admin can delete as well
//first add before deleting
response = api.addRole("test",
helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.deleteRole("test", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
all = (TreeSet<RoleProp>) api.getAllRoles().object;
assertTrue(all.size() == 0);
}
@SuppressWarnings("unchecked")
@Test
public void getAllRolesTest() {
SecurityAPI api = new SecurityAPI();
TreeSet<RoleProp> allRoles = (TreeSet<RoleProp>) api.getAllRoles().object;
assertTrue(allRoles.size() == 0);
api.addRole("role3", helper.loginAsSuperUser());
api.addRole("ROLE2", helper.loginAsSuperUser());
api.addRole("rolE1", helper.loginAsSuperUser());
api.addPrivilege("privilege1", helper.loginAsSuperUser());
api.addPrivilege("privilege2", helper.loginAsSuperUser());
api.addPrivilege("privilege3", helper.loginAsSuperUser());
api.assignPrivilegeToRole("role1", "privilege1", helper.loginAsSuperUser());
api.assignPrivilegeToRole("role1", "privilege2", helper.loginAsSuperUser());
api.assignPrivilegeToRole("role1", "privilege3", helper.loginAsSuperUser());
api.assignPrivilegeToRole("role2", "privilege1", helper.loginAsSuperUser());
allRoles = (TreeSet<RoleProp>) api.getAllRoles().object;
assertTrue(allRoles.size() == 3);
//should be sorted
List<RoleProp> list = new ArrayList<RoleProp>();
list.addAll(allRoles);
assertTrue(list.get(0).role.equals("ROLE1"));
assertTrue(list.get(0).privileges.contains("PRIVILEGE1"));
assertTrue(list.get(0).privileges.contains("PRIVILEGE2"));
assertTrue(list.get(0).privileges.contains("PRIVILEGE3"));
assertTrue(list.get(1).role.equals("ROLE2"));
assertTrue(list.get(2).role.equals("ROLE3"));
}
@SuppressWarnings("unchecked")
@Test
public void assignPrivilegeToRoleTest() {
SecurityAPI api = new SecurityAPI();
APIResponse response = api.addPrivilege("testprivilege",
helper.loginWithPrivilege(Privileges.EDIT_PRIVILEGE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.addRole("testrole",
helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.SUCCESS);
//should have the right privilege to assign
response = api.assignPrivilegeToRole("testrole",
"testprivilege", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.assignPrivilegeToRole("testrole",
"testprivilege", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.assignPrivilegeToRole("testrole",
"testprivilege", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.assignPrivilegeToRole("testrole",
"testprivilege", helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllRoles();
TreeSet<RoleProp> allRoles = (TreeSet<RoleProp>) response.object;
assertTrue(allRoles.first().privileges.contains("TESTPRIVILEGE"));
//cannot assign non existant privilege/role
response = api.assignPrivilegeToRole("testrole",
"non existant privilege", helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.ERROR_RESOURCE_DOES_NOT_EXIST);
response = api.assignPrivilegeToRole("non existant role",
"testprivilege", helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.ERROR_RESOURCE_DOES_NOT_EXIST);
//admin can assign as well
api.addPrivilege("testprivilege2", helper.loginAsSuperUser());
response = api.assignPrivilegeToRole("testrole",
"testprivilege2", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllRoles();
allRoles = (TreeSet<RoleProp>) response.object;
assertTrue(allRoles.first().privileges.contains("TESTPRIVILEGE2"));
}
@SuppressWarnings("unchecked")
@Test
public void unassignPrivilegeToRoleTest() {
SecurityAPI api = new SecurityAPI();
APIResponse response = api.addPrivilege("testprivilege",
helper.loginWithPrivilege(Privileges.EDIT_PRIVILEGE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.addRole("testrole",
helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.SUCCESS);
//should have the right privilege to assign
response = api.assignPrivilegeToRole("testrole",
"testprivilege", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
response = api.unassignPrivilegeToRole("testrole",
"testprivilege", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.unassignPrivilegeToRole("testrole",
"testprivilege", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.unassignPrivilegeToRole("testrole",
"testprivilege", helper.loginWithPrivilege(Privileges.EDIT_ROLE));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllRoles();
TreeSet<RoleProp> allRoles = (TreeSet<RoleProp>) response.object;
assertTrue(! allRoles.first().privileges.contains("TESTPRIVILEGE"));
//admin can unassign as well
response = api.unassignPrivilegeToRole("testrole",
"testprivilege", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
}
@Test
public void addUserTest() {
SecurityAPI api = new SecurityAPI();
//should have the right privilege
APIResponse response = api.addUser("test@Test.com", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.addUser("test@Test.com", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.addUser("test@Test.com", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.addUser("test@Test.com",
helper.loginWithPrivilege(Privileges.EDIT_USER));
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getUser("TEST@tESt.com");
UserProp userProp = (UserProp) response.object;
assertTrue(userProp.email.equals("test@test.com"));
//adding the same user again should give correct error
response = api.addUser("test@TEST.COM",
helper.loginWithPrivilege(Privileges.EDIT_USER));
assertTrue(response.statusCode == Status.ERROR_RESOURCE_ALREADY_EXISTS);
//admin can add as well
response = api.addUser("test2@test.com", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
response = api.getAllUsers();
response = api.getUser("test2@test.com");
userProp = (UserProp) response.object;
assertTrue(response.statusCode == Status.SUCCESS);
assertTrue(userProp.email.equals("test2@test.com"));
}
@Test
public void deleteUserTest() {
SecurityAPI api = new SecurityAPI();
//should have the right privilege
APIResponse response = api.addUser("test@Test.com",
helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
assertTrue(api.getUser("test@test.com").object != null);
response = api.deleteUser("test@Test.com", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.deleteUser("test@Test.com", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.deleteUser("test@Test.com",
helper.loginWithPrivilege(Privileges.EDIT_USER));
assertTrue(response.statusCode == Status.SUCCESS);
assertTrue(api.getUser("test@test.com").object == null);
//admin can delete as well
//first add and then delete
response = api.addUser("test2@Test.com", helper.loginAsSuperUser());
response = api.deleteUser("test2@test.com", helper.loginAsSuperUser());
assertTrue(api.getUser("test@test.com").object == null);
}
@Test
public void getUserTest() {
SecurityAPI api = new SecurityAPI();
assertTrue(api.getUser("test@test.com").object == null);
api.addUser("test@test.com", helper.loginAsSuperUser());
api.addPrivilege("privilege1", helper.loginAsSuperUser());
api.addPrivilege("privilege2", helper.loginAsSuperUser());
api.addRole("role1", helper.loginAsSuperUser());
api.assignPrivilegeToRole("role1", "privilege1", helper.loginAsSuperUser());
api.assignPrivilegeToUser("test@test.com", "privilege2", helper.loginAsSuperUser());
api.assignRoleToUser("test@test.com", "role1", helper.loginAsSuperUser());
UserProp userProp = (UserProp) api.getUser("test@test.com").object;
assertTrue(userProp.email.equals("test@test.com"));
assertTrue(userProp.privileges.contains("PRIVILEGE2"));
assertTrue(userProp.roles.first().role.equals("ROLE1"));
assertTrue(userProp.roles.first().privileges.contains("PRIVILEGE1"));
}
@Test
public void getAllUsersTest() {
SecurityAPI api = new SecurityAPI();
api.addUser("sathya@test.com", helper.loginAsSuperUser());
api.addUser("SOWMYA@test.com", helper.loginAsSuperUser());
api.addUser("thilaKan@test.com", helper.loginAsSuperUser());
api.addUser("Hema@test.com", helper.loginAsSuperUser());
APIResponse response = api.getAllUsers();
assertTrue(response.statusCode == Status.SUCCESS);
@SuppressWarnings("unchecked")
TreeSet<UserProp> all = (TreeSet<UserProp>) response.object;
assertTrue(all.size() == 4);
List<UserProp> list = new ArrayList<UserProp>();
list.addAll(all);
assertTrue(list.get(0).email.equals("hema@test.com"));
assertTrue(list.get(1).email.equals("sathya@test.com"));
assertTrue(list.get(2).email.equals("sowmya@test.com"));
assertTrue(list.get(3).email.equals("thilakan@test.com"));
}
@Test
public void assignRoleToUserTest() {
SecurityAPI api = new SecurityAPI();
api.addUser("test@test.com", helper.loginAsSuperUser());
api.addRole("role1", helper.loginAsSuperUser());
api.addPrivilege("privilege1", helper.loginAsSuperUser());
api.assignPrivilegeToRole("role1", "privilege1", helper.loginAsSuperUser());
APIResponse response = api.assignRoleToUser("test@test.com", "role1", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.assignRoleToUser("test@test.com", "role1",
helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.assignRoleToUser("test@test.com", "role1",
helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.assignRoleToUser("test@test.com", "role1",
helper.loginWithPrivilege(Privileges.EDIT_USER));
assertTrue(response.statusCode == Status.SUCCESS);
UserProp userProp = (UserProp) api.getUser("test@test.com").object;
assertTrue(userProp.email.equals("test@test.com"));
assertTrue(userProp.roles.first().role.equals("ROLE1"));
assertTrue(userProp.roles.first().privileges.contains("PRIVILEGE1"));
}
@Test
public void unassignRoleToUserTest() {
SecurityAPI api = new SecurityAPI();
api.addUser("test@test.com", helper.loginAsSuperUser());
api.addRole("role1", helper.loginAsSuperUser());
api.addRole("role2", helper.loginAsSuperUser());
api.addPrivilege("privilege1", helper.loginAsSuperUser());
api.assignPrivilegeToRole("role1", "privilege1", helper.loginAsSuperUser());
api.assignRoleToUser("test@test.com", "role1", helper.loginAsSuperUser());
api.assignRoleToUser("test@test.com", "role2", helper.loginAsSuperUser());
APIResponse response = api.unassignRoleToUser("test@test.com", "role2", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.unassignRoleToUser("test@test.com", "role2",
helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.unassignRoleToUser("test@test.com", "role2",
helper.loginWithPrivilege(Privileges.EDIT_USER));
assertTrue(response.statusCode == Status.SUCCESS);
UserProp userProp = (UserProp) api.getUser("test@test.com").object;
assertTrue(userProp.roles.size() == 1);
assertTrue(userProp.roles.first().role.equals("ROLE1"));
//admin can also unassign
response = api.unassignRoleToUser("test@test.com", "role1",
helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
userProp = (UserProp) api.getUser("test@test.com").object;
assertTrue(userProp.roles.size() == 0);
}
@Test
public void assignPrivilegeToUserTest() {
SecurityAPI api = new SecurityAPI();
api.addPrivilege("privilege1", helper.loginAsSuperUser());
api.addPrivilege("privilege2", helper.loginAsSuperUser());
api.addUser("test@test.com", helper.loginAsSuperUser());
APIResponse response = api.assignPrivilegeToUser("test@test.com",
"privilege1", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.assignPrivilegeToUser("test@test.com",
"privilege1", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.assignPrivilegeToUser("test@test.com",
"privilege1", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.assignPrivilegeToUser("test@test.com",
"privilege1", helper.loginWithPrivilege(Privileges.EDIT_USER));
assertTrue(response.statusCode == Status.SUCCESS);
UserProp userProp = (UserProp) api.getUser("test@test.com").object;
assertTrue(userProp.privileges.contains("PRIVILEGE1"));
//no exception
//admin can assign as well
response = api.assignPrivilegeToUser("test@test.com",
"privilege2", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
userProp = (UserProp) api.getUser("test@test.com").object;
assertTrue(userProp.privileges.contains("PRIVILEGE2"));
}
@Test
public void unassignPrivilegeToUserTest() {
SecurityAPI api = new SecurityAPI();
api.addPrivilege("privilege1", helper.loginAsSuperUser());
api.addPrivilege("privilege2", helper.loginAsSuperUser());
String email = "test@dummy1fkj.com";
api.addUser(email, helper.loginAsSuperUser());
api.assignPrivilegeToUser(email, "privilege1",
helper.loginAsSuperUser());
api.assignPrivilegeToUser(email, "privilege2",
helper.loginAsSuperUser());
APIResponse response = api.unassignPrivilegeToUser(email,
"privilege1", null);
assertTrue(response.statusCode == Status.ERROR_LOGIN_REQUIRED);
response = api.unassignPrivilegeToUser(email,
"privilege1", helper.loginAsInvalidUser());
assertTrue(response.statusCode == Status.ERROR_INVALID_USER);
response = api.unassignPrivilegeToUser(email,
"privilege1", helper.loginAsValidUser());
assertTrue(response.statusCode == Status.ERROR_INSUFFICIENT_PERMISSION);
response = api.unassignPrivilegeToUser(email,
"privilege1", helper.loginAsSuperUser());
System.out.println("status 1: " + response.statusCode);
UserProp userProp = (UserProp) api.getUser(email).object;
assertTrue(! userProp.privileges.contains("PRIVILEGE1"));
System.out.println("user prop: " + userProp);
assertTrue(response.statusCode == Status.SUCCESS);
//admin can unassign as well
response = api.unassignPrivilegeToUser(email,
"privilege2", helper.loginAsSuperUser());
assertTrue(response.statusCode == Status.SUCCESS);
userProp = (UserProp) api.getUser(email).object;
assertTrue(! userProp.privileges.contains("PRIVILEGE2"));
}
public static void purgeAllSecurityEntities() {
List<Key<UserEntity>> userEntityKeys =
ofy().load().type(UserEntity.class).keys().list();
ofy().delete().keys(userEntityKeys).now();
List<Key<RoleEntity>> roleEntityKeys =
ofy().load().type(RoleEntity.class).keys().list();
ofy().delete().keys(roleEntityKeys).now();
List<Key<PrivilegeEntity>> privilegeEntityKeys =
ofy().load().type(PrivilegeEntity.class).keys().list();
ofy().delete().keys(privilegeEntityKeys).now();
}
}